package com.example.utils;

import java.util.Arrays;

public class ArrayUtil {
    public static void main(String[] args) {
        int[] arr = {1,2,3,3,3,2,1,2,4,3};

        // int[] temp = Arrays.copyOf(arr,arr.length+3);

        //System.out.println(Arrays.toString(temp));

        //int[] temp = delByTarget(arr,2);
        //int[] temp = delByIndex(arr,4);
        //int[] temp = shuffle(arr);


//
//        System.out.println(Arrays.toString(delDoubleElement3(arr)));
//        System.out.println(Arrays.toString(directsort(arr)));

        System.out.println(Arrays.toString(selectSort(arr)));

        int [] arry={1,2,3,4,5};
        System.out.println(Arrays.toString(addElement(arry,3,100)));
    }

    /**
     * 删除数组中指定的元素
     * @param arr
     * @param target
     * @return
     */
    public static int[] delByTarget(int[] arr,int target){
        //1. 判断参数的有效性
        if(null==arr || arr.length==0)
            return arr;

        //2. 确定新的数组的长度
        //新的数组中的元素肯定是不包含target
        int count = 0;//计数器

        //遍历原来的数组
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == target)
                count++;//统计出target出现的次数
        }

        //判断target在arr中是否出现过
        if(count==0)
            return arr;//说明target并没有出现

        //target出现了 - 确定新的数组的长度
        int[] temp = new int[arr.length-count];
        //定义一个下标计数器
        int pos = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]!=target){
                temp[pos++] = arr[i];
            }
        }
        return temp;
    }

    /**
     * 根据下标进行删除 - 唯一性的
     * @param arr
     * @param pos
     * @return
     */
    public static int[] delByIndex(int[] arr,int pos){
        if(null==arr || arr.length==0)
            return arr;

        if(pos<0 || pos>arr.length-1)
            return arr;

        int[] temp = new int[arr.length-1];

        int index = 0;

        for (int i = 0; i < arr.length; i++) {
            if(i!=pos)
                temp[index++] = arr[i];
        }

        return temp;
    }

    /**
     * 随机打乱一个数组
     * @param arr
     * @return
     */
    public static int[] shuffle(int[] arr){
        if(null==arr || arr.length==0)
            return arr;

        int[] temp = new int[arr.length];

        int pos = 0;

        do{//前置循环
            //随机一个下标
            int index = (int) (Math.random()*arr.length);

            temp[pos++] = arr[index];

            //{};

            arr=delByIndex(arr,index);//根据下标删除

            if(arr.length==0)
                break;
        }while(true);

        return temp;
    }

    /**
     * 数组排重
     * @param arr
     * @return
//     * @see delDoubleElement2
     */
    @Deprecated
    public static int[] delDoubleElement(int[] arr){
        if(null==arr || arr.length==0)
            return arr;

        int[] temp = new int[arr.length];
        int pos = 0;

        //思路  arr = {};
        //     temp = {1,2,3,0,0,0}
        do{
            temp[pos++] = arr[0];

            arr = delByTarget(arr,arr[0]);

            if(arr.length==0)
                break;

        }while(true);

        return Arrays.copyOf(temp,pos);
    }

    public static int[] delDoubleElement2(int[] arr){
        if(null==arr || arr.length==0)
            return arr;

        boolean[] flag = new boolean[arr.length];
        //统一赋值
        Arrays.fill(flag,true);

        //思路
        //{1,2,3,3,3,2,1,2,4,3};
        //{T,T,T,F,F,F,F,F,T,F}

        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i] == arr[j])
                    flag[j] = false;
            }
        }

        int count = 0;

        for (int i = 0; i < flag.length; i++) {
            if(flag[i])
                count++;
        }
        int[] temp = new int[count];
        int pos = 0;

        for (int i = 0; i < arr.length; i++) {
            if(flag[i])
                temp[pos++] = arr[i];
        }

        return temp;
    }

    public static int[] delDoubleElement3(int[] arr){
        if(null==arr || arr.length==0)
            return arr;
        //{1,2,3,3,3,2,1,2,4,3};

        //[1, 2, 3, 3, 2, 4]
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i] == arr[j]){
                    arr = delByIndex(arr,j);
                    j--;
                }
            }
        }
        return arr;
    }

    /***
     * 选择排序
     * 每一轮都可以找到有一个最小值在左边
     */

    public  static  int[]  selectSort(int []arr){
        if(arr.length==0 || arr== null){
            return  arr;
        }
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length;j++){
                if(arr[i]<arr[j]){
                    arr[i]=arr[i]^arr[j];
                    arr[j]=arr[i]^arr[j];
                    arr[i]=arr[i]^arr[j];

                }
            }
        }
        return  arr;
    }

    /**
     * 冒泡排序
     * 3 2 1 5 7 6
     * 每次可以找出一个最大值  在最右边
     */

    public  static  int [] Bubaeelsort(int []arr){
        if(arr==null || arr.length==0){
            return  arr;
        }
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    arr[j]=arr[j]^arr[j+1];
                    arr[j+1]=arr[j]^arr[j+1];
                    arr[j]=arr[j]^arr[j+1];
                }
            }
        }
        return  arr;
    }

    /**
     * 插入排序
     */

    public  static  int [] directsort(int [] arr){
        if(arr==null ||arr.length==0){
            return   arr;

        }
        for(int i=1;i<arr.length;i++){
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    arr[j]=arr[j]^arr[j-1];
                    arr[j-1]=arr[j]^arr[j-1];
                    arr[j]=arr[j]^arr[j-1];
                }
            }
        }
        return  arr;

    }
    //向数组中指定位置下面插入一个元素
    public  static  int []  addElement(int [] arr, int pos,int target){

        /**
         *  pos=2
         *  1 2 3 4 5
         *
         *  1. src - 原数组对象
         *
         * 2. srcPos - 拷贝的起始的索引
         *
         * 3. dest - 目标数组
         *
         * 4. destPos - 从目标数组的第几个位置开始放
         *
         * 5. length - 拷贝的数量
         */
        int []temp=new int[arr.length+1];
        //pos 这里是个数
        System.arraycopy(arr,0,temp,0,pos);
        //这里是下标
        temp[pos]=target;
        System.arraycopy(arr,pos,temp,pos+1,arr.length-pos);
        return temp;
    }
}
